Developing and managing petroleum resources often entails committing large economic investments over many years with an expectation of receiving correspondingly large financial returns. Whether a petroleum reservoir yields profit or loss depends largely upon the strategies and tactics implemented for reservoir development and management. Reservoir development planning involves devising and/or selecting strong strategies and tactics that will yield favorable economic results over the long term.
Reservoir development planning may include making decisions regarding size, timing, and location of production platforms as well as subsequent expansions and connections, for example. Key decisions can involve the number, location, allocation to platforms, and timing of wells to be drilled and completed in each field. Post drilling decisions may include determining production rate allocations across multiple wells. Any one decision or action may have system-wide implications, for example propagating positive or negative impact across a petroleum operation or a reservoir. In view of the aforementioned aspects of reservoir development planning, which are only a representative few of the many decisions facing a manager of petroleum resources, one can appreciate the value and impact of planning.
Computer-based modeling holds significant potential for reservoir development planning, particularly when combined with advanced mathematical techniques. Computer-based planning tools support making good decisions. One type of planning tool includes methodology for identifying an optimal solution to a set of decisions based on processing various information inputs. For example, an exemplary optimization model may work towards finding solutions that yield the best outcome from known possibilities with a defined set of constraints. Accordingly, a petroleum operation may achieve great economic benefit via properly applying optimization models for optimizing the development plans and management of petroleum resources, particularly those involving decision-making for multiple oil or gas fields over a multiple years.
The terms “optimal,” “optimizing,” “optimize,” “optimality,” “optimization” (as well as derivatives and other forms of those terms and linguistically related words and phrases), as used herein, are not intended to be limiting in the sense of requiring the present invention to find the best solution or to make the best decision. Although a mathematically optimal solution may in fact arrive at the best of all mathematically available possibilities, real-world embodiments of optimization routines, methods, models, and processes may work towards such a goal without ever actually achieving perfection. Accordingly, one of ordinary skill in the art having benefit of the present disclosure will appreciate that these terms, in the context of the scope of the present invention, are more general. The terms can describe working towards a solution which may be the best available solution, a preferred solution, or a solution that offers a specific benefit within a range of constraints; or continually improving; or refining; or searching for a high point or a maximum for an objective; or processing to reduce a penalty function; etc.
In certain exemplary embodiments, an optimization model can be an algebraic system of functions and equations comprising (1) decision variables of either continuous or integer variety which may be limited to specific domain ranges, (2) constraint equations, which are based on input data (parameters) and the decision variables, that restrict activity of the variables within a specified set of conditions that define feasibility of the optimization problem being addressed, and/or (3) an objective function based on input data (parameters) and the decision variables being optimized, either by maximizing the objective function or minimizing the objective function. In some variations, optimization models may include non-differentiable, black-box and other non-algebraic functions or equations.
A typical (deterministic) mathematical optimization problem involves minimization or maximization of some objective function subject to a set of constraints on problem variables. These problems can often be formulated as a Dynamic Programming (DP) problem. In a DP problem, the decision time horizon is partitioned into a set of “stages” and the system exists in one of several “states.” It may be helpful visualizing the DP problem as an X-Y coordinate system, where the x-axis is represented by the “stages” and the y-axis is represented by the “states.” At each “stage”, the decision-maker takes an “action” or decision, which results in the system transitioning from one state at one stage to a different state in the next stage. In one type of DP problem, the objective function can be minimized to determine the total cost or maximized to determine the total revenue over the entire planning horizon. Before the system transitions, a cost/revenue is incurred at each stage based upon the chosen decision and on the current state. It is assumed that the cost function is separable across stages and that the system is Markovian; i.e., the state to which the system transitions in stage n+1 depends only on its state in stage n and the action taken in stage n.
A dynamic program can be represented as (S, A, R) where S is the state space, A(s) is the set of actions that can be taken in state s, and R(s,a) is the reward for choosing action a in state s. The dynamic program is formulated as a recursive optimization problem as shown below:
                                          1.            ⁢                                                  ⁢                          J              n              *                        ⁢                                          (                s                )                                            a                .                                              =                                                                                                               a                                    ⁢                  min                                ⁡                                  [                                                            c                      ⁡                                              (                                                  s                          ,                          a                                                )                                                              +                                                                  J                                                  n                          +                          1                                                *                                            ⁡                                              (                                                  f                          ⁡                                                      (                                                          s                              ,                              a                                                        )                                                                          )                                                                              ]                                            ⁢                                                          ⁢              for              ⁢                                                          ⁢              n                        =            1                          ,        2        ,        3        ,                  …          ⁢                                          ⁢          N                                        2.        ⁢                                  ⁢        Where                                          3.          ⁢                                          ⁢                                    J              n              *                        ⁡                          (              s              )                                      =                  optimal          ⁢                                          ⁢          cost          ⁢                      -                    ⁢          to          ⁢                      -                    ⁢          go          ⁢                                          ⁢          function          ⁢                                          ⁢          in          ⁢                                          ⁢          stage          ⁢                                          ⁢          n          ⁢                                          ⁢          given          ⁢                                          ⁢          state          ⁢                                          ⁢          s                                                  4.          ⁢                                          ⁢                      c            ⁡                          (                              s                ,                a                            )                                      =                  cost          ⁢                                          ⁢          of          ⁢                                          ⁢          choosing          ⁢                                          ⁢          action          ⁢                                          ⁢          a          ⁢                                          ⁢          in          ⁢                                          ⁢          state          ⁢                                          ⁢          s                                                  5.          ⁢                                          ⁢                      f            ⁡                          (                              s                ,                a                            )                                      =                ⁢                              transition            ⁢                                                  ⁢            function            ⁢                                                  ⁢            that            ⁢                                                  ⁢            determines            ⁢                                                  ⁢            state            ⁢                                                  ⁢            in            ⁢                                                  ⁢            stage            ⁢                                                  ⁢            n                    +          1                                                                  ⁢                                                                            ⁢                                  given                  ⁢                                                                          ⁢                  that                  ⁢                                                                          ⁢                  system                  ⁢                                                                          ⁢                  is                  ⁢                                                                          ⁢                  in                  ⁢                                                                          ⁢                  state                  ⁢                                                                          ⁢                  s                  ⁢                                                                          ⁢                  in                  ⁢                                                                          ⁢                  stage                  ⁢                                                                          ⁢                  n                  ⁢                                                                          ⁢                  and                                                                                                                        ⁢                                  action                  ⁢                                                                          ⁢                  a                  ⁢                                                                          ⁢                  is                  ⁢                                                                          ⁢                                      chosen                    .                                                                                          
The final reward, JN*(s), is assumed to be known. The goal of the dynamic program is to find Jo*(so) where so is the initial state of the system. Dynamic programs may be solved using backward recursion when the time horizon is finite. However, when the time horizon is infinite, dynamic programs may be solved using algorithms such as value/policy iteration.
Solving the problem to mathematical optimality can comprise finding values for the decision variables such that all constraints are satisfied, wherein it is essentially mathematically impossible to improve upon the value of the objective function by changing variable values while still remaining feasible with respect to all of the constraints. When some of the “known” fixed parameters of the problem are actually uncertain in practice, a common approach in decision-making is to ignore the uncertainty and model the problem as a deterministic optimization problem. However, the solution to the deterministic optimization problem may be sub-optimal, or possibly even infeasible, especially if the problem parameters take values that are ultimately different than those values chosen to be used as input into the optimization model that is solved.
The optimization process of reservoir development planning can be challenging, even under the assumption that the economics and behavior of reservoir and surface facilities are fully known. Typically, a large number of soft and hard constraints apply to an even larger number of decision variables. In practice, however, there exists uncertainty in reservoir behavior, economics, and/or other components of the decision process, which complicate the optimization process.